package cn.com.mjsoft.framework.util;

import org.apache.log4j.Logger;

/**
 * 字符工具类
 * 
 * @author mjsoft
 * 
 */
public class StringUtil
{

    /**
     * String是否为空
     * 
     * @param input
     * @return
     */
    public static boolean isStringNull( String input )
    {
        if( null == input || input.trim().equals( "" ) )
        {
            return true;
        }
        return false;
    }

    public static boolean isStringNotNull( String input )
    {
        if( null == input || input.trim().equals( "" ) )
        {
            return false;
        }
        return true;
    }

    /**
     * 是否为比较运算符
     * 
     * @param input
     * @return
     */
    public static boolean isCompare( String input )
    {
        boolean flag = false;
        if( isStringNull( input ) )
        {
            return false;
        }
        String str = input.trim();
        if( str.equals( "<" ) || str.equals( ">" ) || str.equals( ">=" ) || str.equals( "<=" )
            || str.equals( "=" ) || str.equals( "==" ) )
        {
            flag = true;
        }
        return flag;
    }

    /**
     * 将String转换成int，转换失败用replace替代
     * 
     * @param intStr
     * @param replace
     * @return int
     */
    public static int getIntValue( String intStr, int replacement )
    {
        if( intStr == null )
        {
            return replacement;
        }

        int returnValue;
        try
        {
            returnValue = Integer.parseInt( intStr.trim() );
        }
        catch ( NumberFormatException e )
        {
            returnValue = replacement;// 转换失败的话用替代值
        }
        return returnValue;
    }

    /**
     * 将String转换成long，出现转换错误用replace替代
     * 
     * @param longStr
     * @param replace
     * @return long
     */
    public static long getLongValue( String longStr, long replacement )
    {
        if( longStr == null )
        {
            return replacement;
        }

        long returnValue;
        try
        {
            returnValue = Long.parseLong( longStr.trim() );
        }
        catch ( NumberFormatException e )
        {
            returnValue = replacement;// 转换失败的话用替代值
        }
        return returnValue;
    }

    /**
     * 将String转换成boolean，出现转换错误用replace替代
     * 
     * @param boolStr
     * @param replacement
     * @return
     */
    public static boolean getBooleanValue( String boolStr, boolean replacement )
    {
        if( boolStr == null )
        {
            return replacement;
        }

        boolean returnValue;
        try
        {
            returnValue = Boolean.parseBoolean( boolStr.trim() );
        }
        catch ( NumberFormatException e )
        {
            returnValue = replacement;// 转换失败的话用替代值
        }
        return returnValue;
    }

    /**
     * 将String转换成double，出现转换错误用replace替代
     * 
     * @param longStr
     * @param replace
     * @return double
     */
    public static double getDoubleValue( String doubleStr, double replacement )
    {
        if( doubleStr == null )
        {
            return replacement;
        }

        double returnValue;
        try
        {
            returnValue = Double.parseDouble( doubleStr.trim() );
        }
        catch ( NumberFormatException e )
        {
            returnValue = replacement;// 转换失败的话用替代值
        }
        return returnValue;
    }

    /**
     * 将String转换成float，出现转换错误用replace替代
     * 
     * @param longStr
     * @param replace
     * @return double
     */
    public static float getFloatValue( String fStr, float replacement )
    {
        if( fStr == null )
        {
            return replacement;
        }

        float returnValue;
        try
        {
            returnValue = Float.parseFloat( fStr.trim() );
        }
        catch ( NumberFormatException e )
        {
            returnValue = replacement;// 转换失败的话用替代值
        }
        return returnValue;
    }

    /**
     * 字符串不可为null或""
     * 
     * @param str
     * @param replace
     * @return String
     */
    public static String getNotNullString( String str, String replacement )
    {
        if( null == str || str.trim().equals( "" ) )
        {
            return replacement;
        }
        return str.trim();
    }

    /**
     * 空String返回""，防止null存在
     * 
     * @param str
     * @return String
     */
    public static String getNotNullString( String str )
    {
        if( null == str || str.trim().equals( "" ) )
        {
            return "";
        }
        return str.trim();
    }

    /**
     * 是数字字符串吗？
     * 
     * @param str
     * @param boolean true：负值不合法 false:合法
     * @return
     */
    public static boolean isNum( String str, boolean minus )
    {
        boolean isnum = true;
        try
        {
            int value = Integer.parseInt( str.trim() );
            if( value < 0 && minus )// 负值是否合法
                return false;
        }
        catch ( NumberFormatException e )
        {
            return false;
        }
        return isnum;
    }

    public static String notNull( String taregt )
    {
        String end = taregt;
        if( taregt == null )
        {
            end = "";
        }
        return end;
    }

    /**
     * 
     * /** 按指定的规则替换选定的字符串
     * 
     * @param tragetString
     * @param replaceIt
     * @param replacement
     * @return
     */
    public static String replaceString( String tragetString, String replaceIt, String replacement )
    {
        return replaceString( tragetString, replaceIt, replacement, false, false );
    }

    /**
     * 按指定的规则替换选定的字符串
     * 
     * @param tragetString 目标字符
     * @param replaceIt 查询字符
     * @param replacement 替换的字符
     * @param toLowerCase 大小写匹配: true - 不区分大小写, flase - 严格匹配大小写
     * @param prefixMode 是否只替换第一次出现的前缀 : true - 只替换前缀, false - 替换所有字符
     * @return
     */
    public static String replaceString( String tragetString, String replaceIt, String replacement,
        boolean toLowerCase, boolean prefixMode )
    {
        if( tragetString == null || replaceIt == null || replacement == null )
        {
            return tragetString;
        }

        StringBuffer buf = new StringBuffer();
        int legthOfSource = tragetString.length();
        int legthOfReplaceIt = replaceIt.length();
        int postionStart = 0;
        int currentPos;// 每次找到的要替换的字符串的位置

        String tmpStr;
        String tmpReplace;
        if( toLowerCase )
        {
            tmpStr = tragetString.toLowerCase();
            tmpReplace = replaceIt.toLowerCase();
        }
        else
        {
            tmpStr = tragetString;
            tmpReplace = replaceIt;
        }

        while ( ( currentPos = ( tmpStr.indexOf( tmpReplace, postionStart ) ) ) >= 0 )
        {// 当能找到
            buf.append( new String( tragetString.substring( postionStart, currentPos ) ) );// 替换的是真实字符串
            buf.append( replacement );// 替换
            if( prefixMode )
            {
                buf.append( new String( tragetString.substring( tragetString.indexOf( replaceIt )
                    + replaceIt.length() ) ) );
                return buf.toString();
            }
            postionStart = currentPos + legthOfReplaceIt;// 位置移动
        }

        if( postionStart < legthOfSource )
        {// 如果source中已没有需要替换的字符串存在且没有到尾部，就要将剩下的并入结果
            buf.append( new String( tragetString.substring( postionStart ) ) );
        }

        return buf.toString();

    }

    /**
     * 替换所有的空格
     * 
     * @param source
     * @return String
     */
    public static String replaceAllSpace( String source )
    {
        return replaceString( source, " ", "", false, false );
    }

    /**
     * 此方法防止JDK同名方法内存泄露
     * 
     * @param target
     * @param beginIndex
     * @param endIndex
     * @return
     */
    public static String subString( String target, int beginIndex, int endIndex )
    {
        return new String( target.substring( beginIndex, endIndex ) );
    }

    /**
     * 此方法防止JDK(1.4,1.5,1.6)同名方法内存泄露
     * 
     * @param target
     * @param beginIndex
     * @param endIndex
     * @return 新的安全String
     */
    public static String subString( String target, int beginIndex )
    {
        return new String( target.substring( beginIndex ) );
    }

    /**
     * 此方法防止JDK(1.4,1.5,1.6)同名方法内存泄露
     * 
     * @param target
     * @param beginIndex
     * @param endIndex
     * @return
     */
    public static String[] split( String target, String splitChar )
    {
        String[] tmp = target.split( splitChar );
        String[] reArray = new String[tmp.length];

        for ( int i = 0; i < tmp.length; i++ )
        {
            reArray[i] = new String( tmp[i] );
        }

        return reArray;
    }

}
